home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / comm / bbs / wwbbs31_source.lha / WWBBS / Library / files_lib.c < prev    next >
C/C++ Source or Header  |  1995-01-03  |  10KB  |  335 lines
  1. #include "wwbbs.h"
  2. #include "files.h"
  3.  
  4. struct FileNode *GetFileNode(struct FileGroupNode *gnode,ULONG id)
  5.     {
  6.         struct FileNode *ret=NULL;
  7.         {
  8.             struct FileNode *node;
  9.             for(node=(struct FileNode *) gnode->fgn_Files.lh_Head;node->fn_Node.ln_Succ;node=(struct FileNode *) node->fn_Node.ln_Succ)
  10.                 {
  11.                     if(node->fn_ID==id)
  12.                         {
  13.                             ret=node;
  14.                             break;
  15.                         }
  16.                 }
  17.         }
  18.         return(ret);
  19.     }
  20.  
  21. ULONG GetFileFields(struct FileNode *node,struct TagItem *tags_orig)
  22.     {
  23.         ULONG ret=0;
  24.         struct TagItem *tags;
  25.         if(tags=CloneTagItems(tags_orig))
  26.             {
  27.                 if(FilterTagItems(tags,file_tags,TAGFILTER_AND))
  28.                     {
  29.                         struct TagItem *tstate,*tag;
  30.                         APTR data;
  31.                         tstate=tags;
  32.                         while(tag=NextTagItem(&tstate))
  33.                             {
  34.                                 data=(APTR) tag->ti_Data;
  35.                                 switch(tag->ti_Tag)
  36.                                     {
  37.                                         case FILTAG_Name:
  38.                                             *((STRPTR *) data)=node->fn_Name;
  39.                                             break;
  40.                                         case FILTAG_Uploader:
  41.                                             *((STRPTR *) data)=node->fn_Uploader;
  42.                                             break;
  43.                                         case FILTAG_Size:
  44.                                             *((ULONG *) data)=node->fn_Size;
  45.                                             break;
  46.                                         case FILTAG_Date:
  47.                                             *((struct DateStamp **) data)=&node->fn_Date;
  48.                                             break;
  49.                                         case FILTAG_Downloads:
  50.                                             *((UWORD *) data)=node->fn_Downloads;
  51.                                             break;
  52.                                         case FILTAG_LastDownloadDate:
  53.                                             *((struct DateStamp **) data)=&node->fn_LastDownloadDate;
  54.                                             break;
  55.                                         case FILTAG_Description:
  56.                                             *((STRPTR *) data)=node->fn_Description;
  57.                                             break;
  58.                                     }
  59.                                 ret++;
  60.                             }
  61.                     }
  62.                 FreeTagItems(tags);
  63.             }
  64.         return(ret);
  65.     }
  66.  
  67. ULONG SetFileFields(struct FileNode *node,struct TagItem *tags_orig)
  68.     {
  69.         ULONG ret=0,retminus=0;
  70.         struct TagItem *tags;
  71.         if(tags=CloneTagItems(tags_orig))
  72.             {
  73.                 if(FilterTagItems(tags,file_tags,TAGFILTER_AND))
  74.                     {
  75.                         struct TagItem *tstate,*tag;
  76.                         APTR data;
  77.                         tstate=tags;
  78.                         while(tag=NextTagItem(&tstate))
  79.                             {
  80.                                 data=(APTR) tag->ti_Data;
  81.                                 switch(tag->ti_Tag)
  82.                                     {
  83.                                         case FILTAG_Name:
  84.                                             if(data && strlen((STRPTR) data)<=32)
  85.                                                 strcpy(node->fn_Name,(STRPTR) data);
  86.                                             else
  87.                                                 retminus++;
  88.                                             break;
  89.                                         case FILTAG_Uploader:
  90.                                             if(data && strlen((STRPTR) data)<=32)
  91.                                                 strcpy(node->fn_Uploader,(STRPTR) data);
  92.                                             else
  93.                                                 retminus++;
  94.                                             break;
  95.                                         case FILTAG_Size:
  96.                                             node->fn_Size=(ULONG) data;
  97.                                             break;
  98.                                         case FILTAG_Date:
  99.                                             if(data)
  100.                                                 node->fn_Date=*((struct DateStamp *) data);
  101.                                             else
  102.                                                 retminus++;
  103.                                             break;
  104.                                         case FILTAG_Downloads:
  105.                                             node->fn_Downloads=(UWORD) data;
  106.                                             break;
  107.                                         case FILTAG_LastDownloadDate:
  108.                                             if(data)
  109.                                                 node->fn_LastDownloadDate=*((struct DateStamp *) data);
  110.                                             else
  111.                                                 retminus++;
  112.                                             break;
  113.                                         case FILTAG_Description:
  114.                                             if(node->fn_Description)
  115.                                                 {
  116.                                                     FreeVec(node->fn_Description);
  117.                                                     node->fn_Description=NULL;
  118.                                                 }
  119.                                             if(data && (node->fn_Description=AllocVec(strlen((STRPTR) data)+1,MEMF_CLEAR)))
  120.                                                 strcpy(node->fn_Description,(STRPTR) data);
  121.                                             else
  122.                                                 retminus++;
  123.                                             break;
  124.                                     }
  125.                                 ret++;
  126.                             }
  127.                     }
  128.                 FreeTagItems(tags);
  129.             }
  130.         ret-=retminus;
  131.         return(ret);
  132.     }
  133.  
  134. BOOL LoadFileGroup(BYTE *groupname,BYTE *directory)
  135.     {
  136.         BOOL ret=FALSE;
  137.         ObtainSemaphore(&FileGroupSemaphore);
  138.         FlushFileGroups();
  139.         {
  140.             BPTR old_dir,lock;
  141.             if(lock=Lock(directory,SHARED_LOCK))
  142.                 {
  143.                     old_dir=CurrentDir(lock);
  144.                     {
  145.                         struct FileGroupNode *gnode;
  146.                         if(gnode=AllocVec(sizeof(struct FileGroupNode),MEMF_CLEAR))
  147.                             {
  148.                                 InitSemaphore(&gnode->fgn_Semaphore);
  149.                                 NewList(&gnode->fgn_Files);
  150.                                 InitSemaphore(&gnode->fgn_UsageCountSemaphore);
  151.                                 strcpy(gnode->fgn_Name,groupname);
  152.                                 gnode->fgn_Directory=DupLock(lock);
  153.                                 gnode->fgn_Node.ln_Name=gnode->fgn_Name;
  154.                                 {
  155.                                     BPTR count_fh;
  156.                                     if(count_fh=Open(".count",MODE_OLDFILE))
  157.                                         {
  158.                                             ULONG count;
  159.                                             if(FRead(count_fh,&count,sizeof(ULONG),1))
  160.                                                 gnode->fgn_FileCount=count;
  161.                                             Close(count_fh);
  162.                                         }
  163.                                 }
  164.                                 {
  165.                                     BPTR fh;
  166.                                     if(fh=Open(".files",MODE_OLDFILE))
  167.                                         {
  168.                                             BOOL kg=TRUE;
  169.                                             LONG cmd;
  170.                                             struct FileNode *node=NULL;
  171.                                             while(kg)
  172.                                                 {
  173.                                                     cmd=FGetC(fh);
  174.                                                     switch(cmd)
  175.                                                         {
  176.                                                             case -1: /* EOF */
  177.                                                                 kg=FALSE;
  178.                                                                 break;
  179.                                                             case FILCMD_Begin:
  180.                                                                 if(!(node=AllocVec(sizeof(struct FileNode),MEMF_CLEAR)))
  181.                                                                     kg=FALSE;
  182.                                                                 break;
  183.                                                             case FILCMD_End:
  184.                                                                 if(node)
  185.                                                                     {
  186.                                                                         AddTail(&gnode->fgn_Files,(struct Node *) node);
  187.                                                                         node=NULL;
  188.                                                                     }
  189.                                                                 break;
  190.                                                             case FILCMD_Field:
  191.                                                                 if(node)
  192.                                                                     {
  193.                                                                         LONG field;
  194.                                                                         UWORD size;
  195.                                                                         if( ((field=FGetC(fh))!=-1) && (FRead(fh,&size,sizeof(UWORD),1)) )
  196.                                                                             {
  197.                                                                                 APTR data;
  198.                                                                                 if(data=AllocVec(size,MEMF_CLEAR))
  199.                                                                                     {
  200.                                                                                         if(FRead(fh,data,size,1))
  201.                                                                                             {
  202.                                                                                                 switch(field)
  203.                                                                                                     {
  204.                                                                                                         case FILFLD_ID:
  205.                                                                                                             node->fn_ID=*((ULONG *) data);
  206.                                                                                                             break;
  207.                                                                                                         case FILFLD_Name:
  208.                                                                                                             strcpy(node->fn_Name,(STRPTR) data);
  209.                                                                                                             break;
  210.                                                                                                         case FILFLD_Uploader:
  211.                                                                                                             strcpy(node->fn_Uploader,(STRPTR) data);
  212.                                                                                                             break;
  213.                                                                                                         case FILFLD_Size:
  214.                                                                                                             node->fn_Size=*((ULONG *) data);
  215.                                                                                                             break;
  216.                                                                                                         case FILFLD_Date:
  217.                                                                                                             node->fn_Date=*((struct DateStamp *) data);
  218.                                                                                                             break;
  219.                                                                                                         case FILFLD_Downloads:
  220.                                                                                                             node->fn_Downloads=*((UWORD *) data);
  221.                                                                                                             break;
  222.                                                                                                         case FILFLD_LastDownloadDate:
  223.                                                                                                             node->fn_LastDownloadDate=*((struct DateStamp *) data);
  224.                                                                                                             break;
  225.                                                                                                         case FILFLD_Description:
  226.                                                                                                             if(node->fn_Description=AllocVec(size,MEMF_CLEAR))
  227.                                                                                                                 strcpy(node->fn_Description,(STRPTR) data);
  228.                                                                                                             break;
  229.                                                                                                     }
  230.                                                                                             }
  231.                                                                                         else
  232.                                                                                             kg=FALSE;
  233.                                                                                         FreeVec(data);
  234.                                                                                     }
  235.                                                                                 else
  236.                                                                                     kg=FALSE;
  237.                                                                             }
  238.                                                                         else
  239.                                                                             kg=FALSE;
  240.                                                                     }
  241.                                                                 break;
  242.                                                         }
  243.                                                 }
  244.                                             Close(fh);
  245.                                         }
  246.                                 }
  247.                                 AddTail(&FileGroupList,(struct Node *) gnode);
  248.                                 ret=TRUE;
  249.                             }
  250.                     }
  251.                     CurrentDir(old_dir);
  252.                     UnLock(lock);
  253.                 }
  254.         }
  255.         ReleaseSemaphore(&FileGroupSemaphore);
  256.         return(ret);
  257.     }
  258.  
  259. BOOL SaveFileGroup(struct FileGroupNode *gnode)
  260.     {
  261.         BOOL ret=FALSE;
  262.         {
  263.             BPTR old_dir,fh;
  264.             old_dir=CurrentDir(gnode->fgn_Directory);
  265.             if(fh=Open(".files",MODE_NEWFILE))
  266.                 {
  267.                     struct FileNode *node;
  268.                     for(node=(struct FileNode *) gnode->fgn_Files.lh_Head;node->fn_Node.ln_Succ;node=(struct FileNode *) node->fn_Node.ln_Succ)
  269.                         {
  270.                             FPutC(fh,FILCMD_Begin);
  271.                             SaveFileField(fh,FILFLD_ID,&node->fn_ID,sizeof(ULONG));
  272.                             SaveFileString(fh,FILFLD_Name,node->fn_Name);
  273.                             SaveFileString(fh,FILFLD_Uploader,node->fn_Uploader);
  274.                             SaveFileField(fh,FILFLD_Size,&node->fn_Size,sizeof(ULONG));
  275.                             SaveFileField(fh,FILFLD_Date,&node->fn_Date,sizeof(struct DateStamp));
  276.                             SaveFileField(fh,FILFLD_Downloads,&node->fn_Downloads,sizeof(UWORD));
  277.                             SaveFileField(fh,FILFLD_LastDownloadDate,&node->fn_LastDownloadDate,sizeof(struct DateStamp));
  278.                             if(node->fn_Description)
  279.                                 SaveFileString(fh,FILFLD_Description,node->fn_Description);
  280.                             FPutC(fh,FILCMD_End);
  281.                         }
  282.                     {
  283.                         BPTR count_fh;
  284.                         if(count_fh=Open(".count",MODE_NEWFILE))
  285.                             {
  286.                                 FWrite(count_fh,&gnode->fgn_FileCount,sizeof(ULONG),1);
  287.                                 Close(count_fh);
  288.                                 ret=TRUE;
  289.                             }
  290.                     }
  291.                     Close(fh);
  292.                 }
  293.             CurrentDir(old_dir);
  294.         }
  295.         return(ret);
  296.     }
  297.  
  298. void FlushFileGroups()
  299.     {
  300.         struct FileGroupNode *wn,*nn;
  301.         wn=(struct FileGroupNode *) FileGroupList.lh_Head;
  302.         while(nn=(struct FileGroupNode *) wn->fgn_Node.ln_Succ)
  303.             {
  304.                 if(!wn->fgn_UsageCount)
  305.                     {
  306.                         {
  307.                             struct FileNode *node;
  308.                             while(node=(struct FileNode *) RemHead(&wn->fgn_Files))
  309.                                 {
  310.                                     if(node->fn_Description)
  311.                                         FreeVec(node->fn_Description);
  312.                                     FreeVec(node);
  313.                                 }
  314.                         }
  315.                         UnLock(wn->fgn_Directory);
  316.                         Remove((struct Node *) wn);
  317.                         FreeVec(wn);
  318.                     }
  319.                 wn=nn;
  320.             }
  321.     }
  322.  
  323. void SaveFileField(BPTR fh,LONG field,APTR data,UWORD size)
  324.     {
  325.         FPutC(fh,FILCMD_Field);
  326.         FPutC(fh,field);
  327.         FWrite(fh,&size,sizeof(UWORD),1);
  328.         FWrite(fh,data,(ULONG) size,1);
  329.     }
  330.  
  331. void SaveFileString(BPTR fh,LONG field,STRPTR data)
  332.     {
  333.         SaveFileField(fh,field,data,strlen(data)+1);
  334.     }
  335.